import 'package:flutter/material.dart';
import 'dart:async';

/// Dart并发示例
class ConcurrencyExample extends StatefulWidget {
  const ConcurrencyExample({super.key});

  @override
  State<ConcurrencyExample> createState() => _ConcurrencyExampleState();
}

class _ConcurrencyExampleState extends State<ConcurrencyExample> {
  String result = '点击下方按钮查看并发示例';
  bool isLoading = false;

  Future<String> fetchUserData() async {
    // 模拟网络请求
    await Future.delayed(const Duration(seconds: 2));
    return '用户数据加载完成';
  }

  void _demonstrateAsyncAwait() async {
    setState(() {
      isLoading = true;
      result = '正在加载...';
    });

    try {
      String data = await fetchUserData();
      setState(() {
        result = '''
【async/await 示例】

Future<String> fetchUserData() async {
  await Future.delayed(Duration(seconds: 2));
  return '用户数据加载完成';
}

// 使用 await 等待结果
String data = await fetchUserData();

结果: $data

特点:
• async 标记异步函数
• await 等待Future完成
• 代码看起来是同步的，实际是异步的
• 必须在async函数中使用await

等待时间: 2秒
        ''';
        isLoading = false;
      });
    } catch (e) {
      setState(() {
        result = '错误: $e';
        isLoading = false;
      });
    }
  }

  void _demonstrateFuture() {
    setState(() {
      isLoading = true;
      result = '正在使用Future...';
    });

    fetchUserData().then((data) {
      setState(() {
        result = '''
【Future 示例】
Future代表未来会完成的操作。

// 使用 .then() 处理结果
fetchUserData()
  .then((data) {
    print(data);
  })
  .catchError((error) {
    print('错误: \$error');
  })
  .whenComplete(() {
    print('完成');
  });

结果: $data

Future的状态:
• Pending: 等待中
• Completed: 已完成（成功或失败）

常用方法:
• .then() - 处理成功结果
• .catchError() - 处理错误
• .whenComplete() - 无论成功失败都执行
• Future.wait() - 等待多个Future
        ''';
        isLoading = false;
      });
    }).catchError((error) {
      setState(() {
        result = '错误: $error';
        isLoading = false;
      });
    });
  }

  void _demonstrateMultipleFutures() async {
    setState(() {
      isLoading = true;
      result = '同时执行多个异步操作...';
    });

    Future<String> task1() async {
      await Future.delayed(const Duration(seconds: 1));
      return '任务1完成';
    }

    Future<String> task2() async {
      await Future.delayed(const Duration(seconds: 2));
      return '任务2完成';
    }

    Future<String> task3() async {
      await Future.delayed(const Duration(seconds: 1));
      return '任务3完成';
    }

    final startTime = DateTime.now();

    // 并行执行
    List<String> results = await Future.wait([
      task1(),
      task2(),
      task3(),
    ]);

    final duration = DateTime.now().difference(startTime);

    setState(() {
      result = '''
【多个Future并行执行】

Future<String> task1() async {
  await Future.delayed(Duration(seconds: 1));
  return '任务1完成';
}

// 类似的 task2 (2秒) 和 task3 (1秒)

// 并行执行所有任务
List<String> results = await Future.wait([
  task1(),
  task2(), 
  task3(),
]);

结果:
${results[0]}
${results[1]}
${results[2]}

总耗时: ${duration.inMilliseconds}ms
（如果串行执行需要4秒，并行只需2秒）

Future.wait的特点:
• 所有Future并行执行
• 等待全部完成
• 返回结果列表
• 任何一个失败都会抛出错误
      ''';
      isLoading = false;
    });
  }

  void _demonstrateStream() {
    setState(() {
      result = 'Stream开始...';
    });

    StringBuffer output = StringBuffer();
    output.writeln('【Stream 示例】');
    output.writeln('Stream是异步数据序列。\n');

    // 创建Stream
    Stream<int> countStream() async* {
      for (int i = 1; i <= 5; i++) {
        await Future.delayed(const Duration(milliseconds: 500));
        yield i;
      }
    }

    output.writeln('开始监听Stream...\n');
    int count = 0;

    // 监听Stream
    countStream().listen(
      (data) {
        count++;
        setState(() {
          output.writeln('接收到数据 #$count: $data');
          result = output.toString();
        });
      },
      onDone: () {
        setState(() {
          output.writeln('\n✓ Stream完成');
          output.writeln('''
Stream vs Future:
• Future: 返回单个异步结果
• Stream: 返回多个异步结果序列

Stream类型:
• Single-subscription: 只能监听一次
• Broadcast: 可以多次监听

创建Stream:
Stream<int> countStream() async* {
  for (int i = 1; i <= 5; i++) {
    await Future.delayed(Duration(milliseconds: 500));
    yield i; // 产生一个值
  }
}

监听Stream:
stream.listen(
  (data) => print(data),
  onError: (error) => print('错误'),
  onDone: () => print('完成'),
);
          ''');
          result = output.toString();
        });
      },
      onError: (error) {
        setState(() {
          output.writeln('错误: $error');
          result = output.toString();
        });
      },
    );
  }

  void _demonstrateStreamTransform() async {
    setState(() {
      isLoading = true;
      result = '演示Stream转换...';
    });

    Stream<int> numberStream() async* {
      for (int i = 1; i <= 10; i++) {
        await Future.delayed(const Duration(milliseconds: 200));
        yield i;
      }
    }

    // Stream转换
    List<int> doubled = await numberStream()
        .map((n) => n * 2) // 转换
        .where((n) => n > 10) // 过滤
        .toList();

    setState(() {
      result = '''
【Stream转换】
Stream支持类似List的转换操作。

Stream<int> numberStream() async* {
  for (int i = 1; i <= 10; i++) {
    yield i;
  }
}

// 链式转换
List<int> result = await numberStream()
  .map((n) => n * 2)      // 每个值×2
  .where((n) => n > 10)   // 过滤>10的值
  .toList();

原始: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
×2后: [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
过滤后: $doubled

常用Stream方法:
• map() - 转换每个元素
• where() - 过滤元素
• take() - 只取前N个
• skip() - 跳过前N个
• distinct() - 去重
• asyncMap() - 异步转换

StreamController:
用于手动控制Stream的发送:

var controller = StreamController<int>();
controller.stream.listen((data) {
  print(data);
});

controller.add(1);
controller.add(2);
controller.close();
      ''';
      isLoading = false;
    });
  }

  void _demonstrateIsolate() {
    setState(() {
      result = '''
【Isolate（隔离）】
Dart的真正并发机制，每个isolate有独立内存。

import 'dart:isolate';

// 定义耗时任务
void heavyTask(SendPort sendPort) {
  // 执行复杂计算
  int result = 0;
  for (int i = 0; i < 1000000000; i++) {
    result += i;
  }
  sendPort.send(result);
}

// 创建和使用Isolate
Future<void> runIsolate() async {
  final receivePort = ReceivePort();
  
  await Isolate.spawn(
    heavyTask,
    receivePort.sendPort,
  );
  
  final result = await receivePort.first;
  print('结果: \$result');
}

Isolate vs async/await:
┌─────────────┬────────────────┐
│ async/await │ 单线程并发     │
│             │ 不阻塞UI       │
│             │ 共享内存       │
├─────────────┼────────────────┤
│ Isolate     │ 真正的多线程   │
│             │ 独立内存       │
│             │ 适合耗时计算   │
└─────────────┴────────────────┘

Flutter中使用Isolate:
• compute() 函数简化了Isolate使用
• 适用于JSON解析、图像处理等

import 'package:flutter/foundation.dart';

Future<List> parseJson(String json) async {
  return await compute(_parseJsonInIsolate, json);
}

List _parseJsonInIsolate(String json) {
  return jsonDecode(json);
}

注意:
• Isolate之间通过消息通信
• 不能共享内存
• 创建Isolate有开销
• 适合长时间运行的任务
      ''';
    });
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: const Text('Dart 并发'),
        backgroundColor: Theme.of(context).colorScheme.inversePrimary,
      ),
      body: SingleChildScrollView(
        padding: const EdgeInsets.all(16),
        child: Column(
          crossAxisAlignment: CrossAxisAlignment.stretch,
          children: [
            // 说明卡片
            Card(
              color: Colors.cyan.shade50,
              child: const Padding(
                padding: EdgeInsets.all(16),
                child: Column(
                  crossAxisAlignment: CrossAxisAlignment.start,
                  children: [
                    Text(
                      '⚡ 并发概述',
                      style: TextStyle(
                        fontSize: 18,
                        fontWeight: FontWeight.bold,
                      ),
                    ),
                    SizedBox(height: 8),
                    Text(
                      'Dart提供强大的异步编程支持：\n'
                      '• Future：单个异步结果\n'
                      '• async/await：简化异步代码\n'
                      '• Stream：异步数据序列\n'
                      '• Isolate：真正的并发执行',
                      style: TextStyle(fontSize: 14),
                    ),
                  ],
                ),
              ),
            ),
            const SizedBox(height: 16),

            // 代码示例区域
            Container(
              padding: const EdgeInsets.all(16),
              decoration: BoxDecoration(
                color: Colors.grey.shade200,
                borderRadius: BorderRadius.circular(8),
              ),
              child: const Text(
                '''// async/await
Future<String> fetch() async {
  await Future.delayed(Duration(seconds: 1));
  return 'Data';
}

// Future
fetch().then((data) => print(data));

// Stream
Stream<int> count() async* {
  for (int i = 1; i <= 5; i++) {
    yield i;
  }
}

count().listen((n) => print(n));

// Isolate
await Isolate.spawn(task, data);''',
                style: TextStyle(
                  fontFamily: 'monospace',
                  fontSize: 13,
                ),
              ),
            ),
            const SizedBox(height: 16),

            // 加载指示器
            if (isLoading)
              const Center(
                child: Padding(
                  padding: EdgeInsets.all(16),
                  child: CircularProgressIndicator(),
                ),
              ),

            // 交互按钮
            Wrap(
              spacing: 8,
              runSpacing: 8,
              children: [
                ElevatedButton.icon(
                  onPressed: isLoading ? null : _demonstrateAsyncAwait,
                  icon: const Icon(Icons.hourglass_bottom),
                  label: const Text('async/await'),
                ),
                ElevatedButton.icon(
                  onPressed: isLoading ? null : _demonstrateFuture,
                  icon: const Icon(Icons.timeline),
                  label: const Text('Future'),
                ),
                ElevatedButton.icon(
                  onPressed: isLoading ? null : _demonstrateMultipleFutures,
                  icon: const Icon(Icons.multiple_stop),
                  label: const Text('多个Future'),
                ),
                ElevatedButton.icon(
                  onPressed: isLoading ? null : _demonstrateStream,
                  icon: const Icon(Icons.stream),
                  label: const Text('Stream'),
                ),
                ElevatedButton.icon(
                  onPressed: isLoading ? null : _demonstrateStreamTransform,
                  icon: const Icon(Icons.transform),
                  label: const Text('Stream转换'),
                ),
                ElevatedButton.icon(
                  onPressed: _demonstrateIsolate,
                  icon: const Icon(Icons.memory),
                  label: const Text('Isolate'),
                ),
              ],
            ),
            const SizedBox(height: 16),

            // 结果展示区域
            Card(
              elevation: 4,
              child: Container(
                width: double.infinity,
                padding: const EdgeInsets.all(16),
                constraints: const BoxConstraints(minHeight: 150),
                child: Text(
                  result,
                  style: const TextStyle(
                    fontSize: 14,
                    fontFamily: 'monospace',
                  ),
                ),
              ),
            ),
          ],
        ),
      ),
    );
  }
}

